package com.rmd.ai.grpc.service;

import static io.grpc.MethodDescriptor.generateFullMethodName;
import static io.grpc.stub.ClientCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ClientCalls.asyncClientStreamingCall;
import static io.grpc.stub.ClientCalls.asyncServerStreamingCall;
import static io.grpc.stub.ClientCalls.asyncUnaryCall;
import static io.grpc.stub.ClientCalls.blockingServerStreamingCall;
import static io.grpc.stub.ClientCalls.blockingUnaryCall;
import static io.grpc.stub.ClientCalls.futureUnaryCall;
import static io.grpc.stub.ServerCalls.asyncBidiStreamingCall;
import static io.grpc.stub.ServerCalls.asyncClientStreamingCall;
import static io.grpc.stub.ServerCalls.asyncServerStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnaryCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedStreamingCall;
import static io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall;

/**
 * <pre>
 *瑞明达 AI 异步多路IO Grpc 服务
 * </pre>
 */
@javax.annotation.Generated(
    value = "by gRPC proto compiler (version 1.11.0)",
    comments = "Source: ability.proto")
public final class RmdAiServiceGrpc {

  private RmdAiServiceGrpc() {}

  public static final String SERVICE_NAME = "com.rmd.ai.grpc.service.RmdAiService";

  // Static method descriptors that strictly reflect the proto.
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  @java.lang.Deprecated // Use {@link #getAsrMethod()} instead. 
  public static final io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdAsrRequest,
      com.rmd.ai.grpc.service.Ability.RmdAsrResponse> METHOD_ASR = getAsrMethodHelper();

  private static volatile io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdAsrRequest,
      com.rmd.ai.grpc.service.Ability.RmdAsrResponse> getAsrMethod;

  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdAsrRequest,
      com.rmd.ai.grpc.service.Ability.RmdAsrResponse> getAsrMethod() {
    return getAsrMethodHelper();
  }

  private static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdAsrRequest,
      com.rmd.ai.grpc.service.Ability.RmdAsrResponse> getAsrMethodHelper() {
    io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdAsrRequest, com.rmd.ai.grpc.service.Ability.RmdAsrResponse> getAsrMethod;
    if ((getAsrMethod = RmdAiServiceGrpc.getAsrMethod) == null) {
      synchronized (RmdAiServiceGrpc.class) {
        if ((getAsrMethod = RmdAiServiceGrpc.getAsrMethod) == null) {
          RmdAiServiceGrpc.getAsrMethod = getAsrMethod = 
              io.grpc.MethodDescriptor.<com.rmd.ai.grpc.service.Ability.RmdAsrRequest, com.rmd.ai.grpc.service.Ability.RmdAsrResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(
                  "com.rmd.ai.grpc.service.RmdAiService", "Asr"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdAsrRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdAsrResponse.getDefaultInstance()))
                  .setSchemaDescriptor(new RmdAiServiceMethodDescriptorSupplier("Asr"))
                  .build();
          }
        }
     }
     return getAsrMethod;
  }
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  @java.lang.Deprecated // Use {@link #getAsrLargeMethod()} instead. 
  public static final io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdAsrRequest,
      com.rmd.ai.grpc.service.Ability.RmdAsrResponse> METHOD_ASR_LARGE = getAsrLargeMethodHelper();

  private static volatile io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdAsrRequest,
      com.rmd.ai.grpc.service.Ability.RmdAsrResponse> getAsrLargeMethod;

  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdAsrRequest,
      com.rmd.ai.grpc.service.Ability.RmdAsrResponse> getAsrLargeMethod() {
    return getAsrLargeMethodHelper();
  }

  private static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdAsrRequest,
      com.rmd.ai.grpc.service.Ability.RmdAsrResponse> getAsrLargeMethodHelper() {
    io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdAsrRequest, com.rmd.ai.grpc.service.Ability.RmdAsrResponse> getAsrLargeMethod;
    if ((getAsrLargeMethod = RmdAiServiceGrpc.getAsrLargeMethod) == null) {
      synchronized (RmdAiServiceGrpc.class) {
        if ((getAsrLargeMethod = RmdAiServiceGrpc.getAsrLargeMethod) == null) {
          RmdAiServiceGrpc.getAsrLargeMethod = getAsrLargeMethod = 
              io.grpc.MethodDescriptor.<com.rmd.ai.grpc.service.Ability.RmdAsrRequest, com.rmd.ai.grpc.service.Ability.RmdAsrResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(
                  "com.rmd.ai.grpc.service.RmdAiService", "AsrLarge"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdAsrRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdAsrResponse.getDefaultInstance()))
                  .setSchemaDescriptor(new RmdAiServiceMethodDescriptorSupplier("AsrLarge"))
                  .build();
          }
        }
     }
     return getAsrLargeMethod;
  }
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  @java.lang.Deprecated // Use {@link #getEmbeddingMethod()} instead. 
  public static final io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdEmbeddingRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> METHOD_EMBEDDING = getEmbeddingMethodHelper();

  private static volatile io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdEmbeddingRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getEmbeddingMethod;

  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdEmbeddingRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getEmbeddingMethod() {
    return getEmbeddingMethodHelper();
  }

  private static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdEmbeddingRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getEmbeddingMethodHelper() {
    io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdEmbeddingRequest, com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getEmbeddingMethod;
    if ((getEmbeddingMethod = RmdAiServiceGrpc.getEmbeddingMethod) == null) {
      synchronized (RmdAiServiceGrpc.class) {
        if ((getEmbeddingMethod = RmdAiServiceGrpc.getEmbeddingMethod) == null) {
          RmdAiServiceGrpc.getEmbeddingMethod = getEmbeddingMethod = 
              io.grpc.MethodDescriptor.<com.rmd.ai.grpc.service.Ability.RmdEmbeddingRequest, com.rmd.ai.grpc.service.Ability.RmdNlpResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(
                  "com.rmd.ai.grpc.service.RmdAiService", "Embedding"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdEmbeddingRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdNlpResponse.getDefaultInstance()))
                  .setSchemaDescriptor(new RmdAiServiceMethodDescriptorSupplier("Embedding"))
                  .build();
          }
        }
     }
     return getEmbeddingMethod;
  }
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  @java.lang.Deprecated // Use {@link #getFaqMethod()} instead. 
  public static final io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdFaqRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> METHOD_FAQ = getFaqMethodHelper();

  private static volatile io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdFaqRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getFaqMethod;

  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdFaqRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getFaqMethod() {
    return getFaqMethodHelper();
  }

  private static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdFaqRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getFaqMethodHelper() {
    io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdFaqRequest, com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getFaqMethod;
    if ((getFaqMethod = RmdAiServiceGrpc.getFaqMethod) == null) {
      synchronized (RmdAiServiceGrpc.class) {
        if ((getFaqMethod = RmdAiServiceGrpc.getFaqMethod) == null) {
          RmdAiServiceGrpc.getFaqMethod = getFaqMethod = 
              io.grpc.MethodDescriptor.<com.rmd.ai.grpc.service.Ability.RmdFaqRequest, com.rmd.ai.grpc.service.Ability.RmdNlpResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(
                  "com.rmd.ai.grpc.service.RmdAiService", "Faq"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdFaqRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdNlpResponse.getDefaultInstance()))
                  .setSchemaDescriptor(new RmdAiServiceMethodDescriptorSupplier("Faq"))
                  .build();
          }
        }
     }
     return getFaqMethod;
  }
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  @java.lang.Deprecated // Use {@link #getFaqBatchMethod()} instead. 
  public static final io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdFaqBatchRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> METHOD_FAQ_BATCH = getFaqBatchMethodHelper();

  private static volatile io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdFaqBatchRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getFaqBatchMethod;

  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdFaqBatchRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getFaqBatchMethod() {
    return getFaqBatchMethodHelper();
  }

  private static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdFaqBatchRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getFaqBatchMethodHelper() {
    io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdFaqBatchRequest, com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getFaqBatchMethod;
    if ((getFaqBatchMethod = RmdAiServiceGrpc.getFaqBatchMethod) == null) {
      synchronized (RmdAiServiceGrpc.class) {
        if ((getFaqBatchMethod = RmdAiServiceGrpc.getFaqBatchMethod) == null) {
          RmdAiServiceGrpc.getFaqBatchMethod = getFaqBatchMethod = 
              io.grpc.MethodDescriptor.<com.rmd.ai.grpc.service.Ability.RmdFaqBatchRequest, com.rmd.ai.grpc.service.Ability.RmdNlpResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(
                  "com.rmd.ai.grpc.service.RmdAiService", "FaqBatch"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdFaqBatchRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdNlpResponse.getDefaultInstance()))
                  .setSchemaDescriptor(new RmdAiServiceMethodDescriptorSupplier("FaqBatch"))
                  .build();
          }
        }
     }
     return getFaqBatchMethod;
  }
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  @java.lang.Deprecated // Use {@link #getNluMethod()} instead. 
  public static final io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdNluRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> METHOD_NLU = getNluMethodHelper();

  private static volatile io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdNluRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getNluMethod;

  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdNluRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getNluMethod() {
    return getNluMethodHelper();
  }

  private static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdNluRequest,
      com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getNluMethodHelper() {
    io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdNluRequest, com.rmd.ai.grpc.service.Ability.RmdNlpResponse> getNluMethod;
    if ((getNluMethod = RmdAiServiceGrpc.getNluMethod) == null) {
      synchronized (RmdAiServiceGrpc.class) {
        if ((getNluMethod = RmdAiServiceGrpc.getNluMethod) == null) {
          RmdAiServiceGrpc.getNluMethod = getNluMethod = 
              io.grpc.MethodDescriptor.<com.rmd.ai.grpc.service.Ability.RmdNluRequest, com.rmd.ai.grpc.service.Ability.RmdNlpResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(
                  "com.rmd.ai.grpc.service.RmdAiService", "Nlu"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdNluRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdNlpResponse.getDefaultInstance()))
                  .setSchemaDescriptor(new RmdAiServiceMethodDescriptorSupplier("Nlu"))
                  .build();
          }
        }
     }
     return getNluMethod;
  }
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  @java.lang.Deprecated // Use {@link #getPipelineMethod()} instead. 
  public static final io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdPipelineRequest,
      com.rmd.ai.grpc.service.Ability.RmdPipelineResponse> METHOD_PIPELINE = getPipelineMethodHelper();

  private static volatile io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdPipelineRequest,
      com.rmd.ai.grpc.service.Ability.RmdPipelineResponse> getPipelineMethod;

  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdPipelineRequest,
      com.rmd.ai.grpc.service.Ability.RmdPipelineResponse> getPipelineMethod() {
    return getPipelineMethodHelper();
  }

  private static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdPipelineRequest,
      com.rmd.ai.grpc.service.Ability.RmdPipelineResponse> getPipelineMethodHelper() {
    io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdPipelineRequest, com.rmd.ai.grpc.service.Ability.RmdPipelineResponse> getPipelineMethod;
    if ((getPipelineMethod = RmdAiServiceGrpc.getPipelineMethod) == null) {
      synchronized (RmdAiServiceGrpc.class) {
        if ((getPipelineMethod = RmdAiServiceGrpc.getPipelineMethod) == null) {
          RmdAiServiceGrpc.getPipelineMethod = getPipelineMethod = 
              io.grpc.MethodDescriptor.<com.rmd.ai.grpc.service.Ability.RmdPipelineRequest, com.rmd.ai.grpc.service.Ability.RmdPipelineResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(
                  "com.rmd.ai.grpc.service.RmdAiService", "Pipeline"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdPipelineRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdPipelineResponse.getDefaultInstance()))
                  .setSchemaDescriptor(new RmdAiServiceMethodDescriptorSupplier("Pipeline"))
                  .build();
          }
        }
     }
     return getPipelineMethod;
  }
  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  @java.lang.Deprecated // Use {@link #getTtsMethod()} instead. 
  public static final io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdTtsRequest,
      com.rmd.ai.grpc.service.Ability.RmdTtsResponse> METHOD_TTS = getTtsMethodHelper();

  private static volatile io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdTtsRequest,
      com.rmd.ai.grpc.service.Ability.RmdTtsResponse> getTtsMethod;

  @io.grpc.ExperimentalApi("https://github.com/grpc/grpc-java/issues/1901")
  public static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdTtsRequest,
      com.rmd.ai.grpc.service.Ability.RmdTtsResponse> getTtsMethod() {
    return getTtsMethodHelper();
  }

  private static io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdTtsRequest,
      com.rmd.ai.grpc.service.Ability.RmdTtsResponse> getTtsMethodHelper() {
    io.grpc.MethodDescriptor<com.rmd.ai.grpc.service.Ability.RmdTtsRequest, com.rmd.ai.grpc.service.Ability.RmdTtsResponse> getTtsMethod;
    if ((getTtsMethod = RmdAiServiceGrpc.getTtsMethod) == null) {
      synchronized (RmdAiServiceGrpc.class) {
        if ((getTtsMethod = RmdAiServiceGrpc.getTtsMethod) == null) {
          RmdAiServiceGrpc.getTtsMethod = getTtsMethod = 
              io.grpc.MethodDescriptor.<com.rmd.ai.grpc.service.Ability.RmdTtsRequest, com.rmd.ai.grpc.service.Ability.RmdTtsResponse>newBuilder()
              .setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
              .setFullMethodName(generateFullMethodName(
                  "com.rmd.ai.grpc.service.RmdAiService", "Tts"))
              .setSampledToLocalTracing(true)
              .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdTtsRequest.getDefaultInstance()))
              .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
                  com.rmd.ai.grpc.service.Ability.RmdTtsResponse.getDefaultInstance()))
                  .setSchemaDescriptor(new RmdAiServiceMethodDescriptorSupplier("Tts"))
                  .build();
          }
        }
     }
     return getTtsMethod;
  }

  /**
   * Creates a new async stub that supports all call types for the service
   */
  public static RmdAiServiceStub newStub(io.grpc.Channel channel) {
    return new RmdAiServiceStub(channel);
  }

  /**
   * Creates a new blocking-style stub that supports unary and streaming output calls on the service
   */
  public static RmdAiServiceBlockingStub newBlockingStub(
      io.grpc.Channel channel) {
    return new RmdAiServiceBlockingStub(channel);
  }

  /**
   * Creates a new ListenableFuture-style stub that supports unary calls on the service
   */
  public static RmdAiServiceFutureStub newFutureStub(
      io.grpc.Channel channel) {
    return new RmdAiServiceFutureStub(channel);
  }

  /**
   * <pre>
   *瑞明达 AI 异步多路IO Grpc 服务
   * </pre>
   */
  public static abstract class RmdAiServiceImplBase implements io.grpc.BindableService {

    /**
     */
    public void asr(com.rmd.ai.grpc.service.Ability.RmdAsrRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdAsrResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getAsrMethodHelper(), responseObserver);
    }

    /**
     */
    public void asrLarge(com.rmd.ai.grpc.service.Ability.RmdAsrRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdAsrResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getAsrLargeMethodHelper(), responseObserver);
    }

    /**
     */
    public void embedding(com.rmd.ai.grpc.service.Ability.RmdEmbeddingRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdNlpResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getEmbeddingMethodHelper(), responseObserver);
    }

    /**
     */
    public void faq(com.rmd.ai.grpc.service.Ability.RmdFaqRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdNlpResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getFaqMethodHelper(), responseObserver);
    }

    /**
     */
    public void faqBatch(com.rmd.ai.grpc.service.Ability.RmdFaqBatchRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdNlpResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getFaqBatchMethodHelper(), responseObserver);
    }

    /**
     */
    public void nlu(com.rmd.ai.grpc.service.Ability.RmdNluRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdNlpResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getNluMethodHelper(), responseObserver);
    }

    /**
     */
    public void pipeline(com.rmd.ai.grpc.service.Ability.RmdPipelineRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdPipelineResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getPipelineMethodHelper(), responseObserver);
    }

    /**
     */
    public void tts(com.rmd.ai.grpc.service.Ability.RmdTtsRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdTtsResponse> responseObserver) {
      asyncUnimplementedUnaryCall(getTtsMethodHelper(), responseObserver);
    }

    @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
      return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
          .addMethod(
            getAsrMethodHelper(),
            asyncServerStreamingCall(
              new MethodHandlers<
                com.rmd.ai.grpc.service.Ability.RmdAsrRequest,
                com.rmd.ai.grpc.service.Ability.RmdAsrResponse>(
                  this, METHODID_ASR)))
          .addMethod(
            getAsrLargeMethodHelper(),
            asyncServerStreamingCall(
              new MethodHandlers<
                com.rmd.ai.grpc.service.Ability.RmdAsrRequest,
                com.rmd.ai.grpc.service.Ability.RmdAsrResponse>(
                  this, METHODID_ASR_LARGE)))
          .addMethod(
            getEmbeddingMethodHelper(),
            asyncServerStreamingCall(
              new MethodHandlers<
                com.rmd.ai.grpc.service.Ability.RmdEmbeddingRequest,
                com.rmd.ai.grpc.service.Ability.RmdNlpResponse>(
                  this, METHODID_EMBEDDING)))
          .addMethod(
            getFaqMethodHelper(),
            asyncServerStreamingCall(
              new MethodHandlers<
                com.rmd.ai.grpc.service.Ability.RmdFaqRequest,
                com.rmd.ai.grpc.service.Ability.RmdNlpResponse>(
                  this, METHODID_FAQ)))
          .addMethod(
            getFaqBatchMethodHelper(),
            asyncServerStreamingCall(
              new MethodHandlers<
                com.rmd.ai.grpc.service.Ability.RmdFaqBatchRequest,
                com.rmd.ai.grpc.service.Ability.RmdNlpResponse>(
                  this, METHODID_FAQ_BATCH)))
          .addMethod(
            getNluMethodHelper(),
            asyncServerStreamingCall(
              new MethodHandlers<
                com.rmd.ai.grpc.service.Ability.RmdNluRequest,
                com.rmd.ai.grpc.service.Ability.RmdNlpResponse>(
                  this, METHODID_NLU)))
          .addMethod(
            getPipelineMethodHelper(),
            asyncServerStreamingCall(
              new MethodHandlers<
                com.rmd.ai.grpc.service.Ability.RmdPipelineRequest,
                com.rmd.ai.grpc.service.Ability.RmdPipelineResponse>(
                  this, METHODID_PIPELINE)))
          .addMethod(
            getTtsMethodHelper(),
            asyncServerStreamingCall(
              new MethodHandlers<
                com.rmd.ai.grpc.service.Ability.RmdTtsRequest,
                com.rmd.ai.grpc.service.Ability.RmdTtsResponse>(
                  this, METHODID_TTS)))
          .build();
    }
  }

  /**
   * <pre>
   *瑞明达 AI 异步多路IO Grpc 服务
   * </pre>
   */
  public static final class RmdAiServiceStub extends io.grpc.stub.AbstractStub<RmdAiServiceStub> {
    private RmdAiServiceStub(io.grpc.Channel channel) {
      super(channel);
    }

    private RmdAiServiceStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected RmdAiServiceStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new RmdAiServiceStub(channel, callOptions);
    }

    /**
     */
    public void asr(com.rmd.ai.grpc.service.Ability.RmdAsrRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdAsrResponse> responseObserver) {
      asyncServerStreamingCall(
          getChannel().newCall(getAsrMethodHelper(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void asrLarge(com.rmd.ai.grpc.service.Ability.RmdAsrRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdAsrResponse> responseObserver) {
      asyncServerStreamingCall(
          getChannel().newCall(getAsrLargeMethodHelper(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void embedding(com.rmd.ai.grpc.service.Ability.RmdEmbeddingRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdNlpResponse> responseObserver) {
      asyncServerStreamingCall(
          getChannel().newCall(getEmbeddingMethodHelper(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void faq(com.rmd.ai.grpc.service.Ability.RmdFaqRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdNlpResponse> responseObserver) {
      asyncServerStreamingCall(
          getChannel().newCall(getFaqMethodHelper(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void faqBatch(com.rmd.ai.grpc.service.Ability.RmdFaqBatchRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdNlpResponse> responseObserver) {
      asyncServerStreamingCall(
          getChannel().newCall(getFaqBatchMethodHelper(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void nlu(com.rmd.ai.grpc.service.Ability.RmdNluRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdNlpResponse> responseObserver) {
      asyncServerStreamingCall(
          getChannel().newCall(getNluMethodHelper(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void pipeline(com.rmd.ai.grpc.service.Ability.RmdPipelineRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdPipelineResponse> responseObserver) {
      asyncServerStreamingCall(
          getChannel().newCall(getPipelineMethodHelper(), getCallOptions()), request, responseObserver);
    }

    /**
     */
    public void tts(com.rmd.ai.grpc.service.Ability.RmdTtsRequest request,
        io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdTtsResponse> responseObserver) {
      asyncServerStreamingCall(
          getChannel().newCall(getTtsMethodHelper(), getCallOptions()), request, responseObserver);
    }
  }

  /**
   * <pre>
   *瑞明达 AI 异步多路IO Grpc 服务
   * </pre>
   */
  public static final class RmdAiServiceBlockingStub extends io.grpc.stub.AbstractStub<RmdAiServiceBlockingStub> {
    private RmdAiServiceBlockingStub(io.grpc.Channel channel) {
      super(channel);
    }

    private RmdAiServiceBlockingStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected RmdAiServiceBlockingStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new RmdAiServiceBlockingStub(channel, callOptions);
    }

    /**
     */
    public java.util.Iterator<com.rmd.ai.grpc.service.Ability.RmdAsrResponse> asr(
        com.rmd.ai.grpc.service.Ability.RmdAsrRequest request) {
      return blockingServerStreamingCall(
          getChannel(), getAsrMethodHelper(), getCallOptions(), request);
    }

    /**
     */
    public java.util.Iterator<com.rmd.ai.grpc.service.Ability.RmdAsrResponse> asrLarge(
        com.rmd.ai.grpc.service.Ability.RmdAsrRequest request) {
      return blockingServerStreamingCall(
          getChannel(), getAsrLargeMethodHelper(), getCallOptions(), request);
    }

    /**
     */
    public java.util.Iterator<com.rmd.ai.grpc.service.Ability.RmdNlpResponse> embedding(
        com.rmd.ai.grpc.service.Ability.RmdEmbeddingRequest request) {
      return blockingServerStreamingCall(
          getChannel(), getEmbeddingMethodHelper(), getCallOptions(), request);
    }

    /**
     */
    public java.util.Iterator<com.rmd.ai.grpc.service.Ability.RmdNlpResponse> faq(
        com.rmd.ai.grpc.service.Ability.RmdFaqRequest request) {
      return blockingServerStreamingCall(
          getChannel(), getFaqMethodHelper(), getCallOptions(), request);
    }

    /**
     */
    public java.util.Iterator<com.rmd.ai.grpc.service.Ability.RmdNlpResponse> faqBatch(
        com.rmd.ai.grpc.service.Ability.RmdFaqBatchRequest request) {
      return blockingServerStreamingCall(
          getChannel(), getFaqBatchMethodHelper(), getCallOptions(), request);
    }

    /**
     */
    public java.util.Iterator<com.rmd.ai.grpc.service.Ability.RmdNlpResponse> nlu(
        com.rmd.ai.grpc.service.Ability.RmdNluRequest request) {
      return blockingServerStreamingCall(
          getChannel(), getNluMethodHelper(), getCallOptions(), request);
    }

    /**
     */
    public java.util.Iterator<com.rmd.ai.grpc.service.Ability.RmdPipelineResponse> pipeline(
        com.rmd.ai.grpc.service.Ability.RmdPipelineRequest request) {
      return blockingServerStreamingCall(
          getChannel(), getPipelineMethodHelper(), getCallOptions(), request);
    }

    /**
     */
    public java.util.Iterator<com.rmd.ai.grpc.service.Ability.RmdTtsResponse> tts(
        com.rmd.ai.grpc.service.Ability.RmdTtsRequest request) {
      return blockingServerStreamingCall(
          getChannel(), getTtsMethodHelper(), getCallOptions(), request);
    }
  }

  /**
   * <pre>
   *瑞明达 AI 异步多路IO Grpc 服务
   * </pre>
   */
  public static final class RmdAiServiceFutureStub extends io.grpc.stub.AbstractStub<RmdAiServiceFutureStub> {
    private RmdAiServiceFutureStub(io.grpc.Channel channel) {
      super(channel);
    }

    private RmdAiServiceFutureStub(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      super(channel, callOptions);
    }

    @java.lang.Override
    protected RmdAiServiceFutureStub build(io.grpc.Channel channel,
        io.grpc.CallOptions callOptions) {
      return new RmdAiServiceFutureStub(channel, callOptions);
    }
  }

  private static final int METHODID_ASR = 0;
  private static final int METHODID_ASR_LARGE = 1;
  private static final int METHODID_EMBEDDING = 2;
  private static final int METHODID_FAQ = 3;
  private static final int METHODID_FAQ_BATCH = 4;
  private static final int METHODID_NLU = 5;
  private static final int METHODID_PIPELINE = 6;
  private static final int METHODID_TTS = 7;

  private static final class MethodHandlers<Req, Resp> implements
      io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
      io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
    private final RmdAiServiceImplBase serviceImpl;
    private final int methodId;

    MethodHandlers(RmdAiServiceImplBase serviceImpl, int methodId) {
      this.serviceImpl = serviceImpl;
      this.methodId = methodId;
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        case METHODID_ASR:
          serviceImpl.asr((com.rmd.ai.grpc.service.Ability.RmdAsrRequest) request,
              (io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdAsrResponse>) responseObserver);
          break;
        case METHODID_ASR_LARGE:
          serviceImpl.asrLarge((com.rmd.ai.grpc.service.Ability.RmdAsrRequest) request,
              (io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdAsrResponse>) responseObserver);
          break;
        case METHODID_EMBEDDING:
          serviceImpl.embedding((com.rmd.ai.grpc.service.Ability.RmdEmbeddingRequest) request,
              (io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdNlpResponse>) responseObserver);
          break;
        case METHODID_FAQ:
          serviceImpl.faq((com.rmd.ai.grpc.service.Ability.RmdFaqRequest) request,
              (io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdNlpResponse>) responseObserver);
          break;
        case METHODID_FAQ_BATCH:
          serviceImpl.faqBatch((com.rmd.ai.grpc.service.Ability.RmdFaqBatchRequest) request,
              (io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdNlpResponse>) responseObserver);
          break;
        case METHODID_NLU:
          serviceImpl.nlu((com.rmd.ai.grpc.service.Ability.RmdNluRequest) request,
              (io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdNlpResponse>) responseObserver);
          break;
        case METHODID_PIPELINE:
          serviceImpl.pipeline((com.rmd.ai.grpc.service.Ability.RmdPipelineRequest) request,
              (io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdPipelineResponse>) responseObserver);
          break;
        case METHODID_TTS:
          serviceImpl.tts((com.rmd.ai.grpc.service.Ability.RmdTtsRequest) request,
              (io.grpc.stub.StreamObserver<com.rmd.ai.grpc.service.Ability.RmdTtsResponse>) responseObserver);
          break;
        default:
          throw new AssertionError();
      }
    }

    @java.lang.Override
    @java.lang.SuppressWarnings("unchecked")
    public io.grpc.stub.StreamObserver<Req> invoke(
        io.grpc.stub.StreamObserver<Resp> responseObserver) {
      switch (methodId) {
        default:
          throw new AssertionError();
      }
    }
  }

  private static abstract class RmdAiServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
    RmdAiServiceBaseDescriptorSupplier() {}

    @java.lang.Override
    public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
      return com.rmd.ai.grpc.service.Ability.getDescriptor();
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
      return getFileDescriptor().findServiceByName("RmdAiService");
    }
  }

  private static final class RmdAiServiceFileDescriptorSupplier
      extends RmdAiServiceBaseDescriptorSupplier {
    RmdAiServiceFileDescriptorSupplier() {}
  }

  private static final class RmdAiServiceMethodDescriptorSupplier
      extends RmdAiServiceBaseDescriptorSupplier
      implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
    private final String methodName;

    RmdAiServiceMethodDescriptorSupplier(String methodName) {
      this.methodName = methodName;
    }

    @java.lang.Override
    public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
      return getServiceDescriptor().findMethodByName(methodName);
    }
  }

  private static volatile io.grpc.ServiceDescriptor serviceDescriptor;

  public static io.grpc.ServiceDescriptor getServiceDescriptor() {
    io.grpc.ServiceDescriptor result = serviceDescriptor;
    if (result == null) {
      synchronized (RmdAiServiceGrpc.class) {
        result = serviceDescriptor;
        if (result == null) {
          serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
              .setSchemaDescriptor(new RmdAiServiceFileDescriptorSupplier())
              .addMethod(getAsrMethodHelper())
              .addMethod(getAsrLargeMethodHelper())
              .addMethod(getEmbeddingMethodHelper())
              .addMethod(getFaqMethodHelper())
              .addMethod(getFaqBatchMethodHelper())
              .addMethod(getNluMethodHelper())
              .addMethod(getPipelineMethodHelper())
              .addMethod(getTtsMethodHelper())
              .build();
        }
      }
    }
    return result;
  }
}
